{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "39fd1948-b5c3-48c4-b10e-2ae7e8c83334",
   "metadata": {},
   "source": [
    "# Langgraph 搭配千帆 Adpater 使用\n",
    "\n",
    "LangGraph 是由 LangChain Inc. 所推出的一款大模型应用编排框架。它在集成了来自 LangChain 的功能的同时，还提供了通过代码构建有向无环图（DAG），将多个智能体（Agent）或工具（Tool）节点链接在一起，在之间传递数据状态并且最终得出用户期望的输出结果的能力。LangGraph 官方提供了数种使用 LangGraph 来构建应用的样例，下文将介绍如何将这些样例与千帆 Adpater 结合使用，以实现现有 LangGraph 与 ERNIE 系列大模型的无缝对接。\n",
    "\n",
    "# 准备工作\n",
    "\n",
    "需要安装最新版本的 LangGraph 和 LangChain，并安装千帆 Adpater 版本的额外依赖组。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0d7b6dcc-c985-46e2-8457-7e6b0298b950",
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install -U langchain langchain-community langchain_openai langgraph duckduckgo \"qianfan[openai]\"\n",
    "!qianfan --version"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9392084c",
   "metadata": {},
   "source": [
    "接下来将演示如何使用 LangGraph 构建一个多智能体合作的 Demo\n",
    "\n",
    "# 0. 设置\n",
    "\n",
    "在开始之前，我们需要设置一些运行时必须的环境变量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "743c19df-6da9-4d1e-b2d2-ea40080b9fdc",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "# 由于 langchain-openai 的运行逻辑强校验 OPENAI_API_KEY 的存在，因此需要提前设置好\n",
    "# 值可以随便设置\n",
    "os.environ['OPENAI_API_KEY'] = 'any-content-you-want'\n",
    "\n",
    "# 这里需要设置为千帆 Adapter 运行时的地址\n",
    "os.environ['OPENAI_BASE_URL'] = 'http://localhost:8001/v1'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04b8d488",
   "metadata": {},
   "source": [
    "并且在一个独立的终端中使用 `qianfan openai` 来启动一个 Adapter。这个 Adpater 会将所有请求向 OpenAI 的 API 转换为对千帆平台的请求，并且将回包转换为 OpenAI 的回包格式。实现在现有 OpenAI 生态中快速切换到千帆能力上的功能"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e4344a7-21df-4d54-90d2-9d19b3416ffb",
   "metadata": {},
   "source": [
    "# 1. 创建 Agent\n",
    "\n",
    "LangGraph 中的节点可以是多种类型，例如一个被构造为智能体的 Chain。下面我们定义了一个工具函数，用于帮助我们快速构建一个支持传入 tools 和 system 字段作为请求参数的简易 Agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4325a10e-38dc-4a98-9004-e1525eaba377",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain_core.messages import (\n",
    "    BaseMessage,\n",
    "    HumanMessage,\n",
    "    ToolMessage,\n",
    ")\n",
    "from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n",
    "\n",
    "from langgraph.graph import END, StateGraph, START\n",
    "\n",
    "\n",
    "def create_agent(llm, tools, system_message: str):\n",
    "    \"\"\"Create an agent.\"\"\"\n",
    "    prompt = ChatPromptTemplate.from_messages(\n",
    "        [\n",
    "            (\n",
    "                \"system\",\n",
    "                \"You are a helpful AI assistant, collaborating with other assistants.\"\n",
    "                \" Use the provided tools to progress towards answering the question.\"\n",
    "                \" If you are unable to fully answer, that's OK, another assistant with different tools \"\n",
    "                \" will help where you left off. Execute what you can to make progress.\"\n",
    "                \" If you or any of the other assistants have the final answer or deliverable,\"\n",
    "                \" prefix your response with FINAL ANSWER so the team knows to stop.\"\n",
    "                \" You have access to the following tools: {tool_names}.\\n{system_message}\",\n",
    "            ),\n",
    "            MessagesPlaceholder(variable_name=\"messages\"),\n",
    "        ]\n",
    "    )\n",
    "    prompt = prompt.partial(system_message=system_message)\n",
    "    prompt = prompt.partial(tool_names=\", \".join([tool.name for tool in tools]))\n",
    "    return prompt | llm.bind_functions(tools)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4b40de2-5dd4-4d5b-882e-577210723ff4",
   "metadata": {},
   "source": [
    "# 2. 定义工具\n",
    "\n",
    "Agent 的构造除了要使用大模型，还需要传入其可以使用的工具。下面我们就定义了一个用于执行 Python 脚本的解释器工具，和用于获取 mock 数据的搜索工具"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ca076f3b-a729-4ca9-8f91-05c2ba58d610",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Annotated\n",
    "\n",
    "from langchain_core.tools import tool\n",
    "from langchain_experimental.utilities import PythonREPL\n",
    "\n",
    "repl = PythonREPL()\n",
    "\n",
    "\n",
    "@tool\n",
    "def python_repl(\n",
    "    code: Annotated[str, \"The python code to execute to generate your chart.\"],\n",
    "):\n",
    "    \"\"\"Use this to execute python code. If you want to see the output of a value,\n",
    "    you should print it out with `print(...)`. This is visible to the user.\"\"\"\n",
    "    try:\n",
    "        result = repl.run(code)\n",
    "    except BaseException as e:\n",
    "        return f\"Failed to execute. Error: {repr(e)}\"\n",
    "    result_str = f\"Successfully executed:\\n```python\\n{code}\\n```\\nStdout: {result}\"\n",
    "    return (\n",
    "        result_str + \"\\n\\nIf you have completed all tasks, respond with FINAL ANSWER.\"\n",
    "    )\n",
    "\n",
    "@tool\n",
    "def duckduckgo_search(\n",
    "    query: Annotated[str, \"搜索关键词\"],\n",
    "):\n",
    "    \"\"\"使用该工具来搜索 DuckDuckGo 上的内容.\"\"\"\n",
    "    return \"\"\"{\n",
    "  \"GDP_USA_2010_2020\": {\n",
    "    \"2010\": 14964.4,\n",
    "    \"2011\": 15518.9,\n",
    "    \"2012\": 16197.0,\n",
    "    \"2013\": 16784.9,\n",
    "    \"2014\": 17527.3,\n",
    "    \"2015\": 18224.8,\n",
    "    \"2016\": 18745.1,\n",
    "    \"2017\": 19519.4,\n",
    "    \"2018\": 20611.9,\n",
    "    \"2019\": 21433.2,\n",
    "    \"2020\": 20936.6\n",
    "  }\n",
    "}\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1b54c0c-0b09-408b-abc5-86308929afb6",
   "metadata": {},
   "source": [
    "# 3. 创建 Graph\n",
    "\n",
    "现在我们有了工具的定义，以及构建 Agent 的工具函数，接下来我们就可以着手来构建 LangGraph 的 Graph。Graph 中的每个节点代表一个 Agent，每个节点之间的边代表两个 Agent 之间的通信。Graph 的作用是描述 Agent 之间的通信，从而帮助我们构建 Agent 之间的交互。\n",
    "\n",
    "## 3.1 定义状态\n",
    "\n",
    "我们首先需要定义 Graph 的状态。这个状态包含了一个消息列表，以及一个用来追踪最近发送消息节点的 Key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "290c91d4-f6f4-443c-8181-233d39102974",
   "metadata": {},
   "outputs": [],
   "source": [
    "import operator\n",
    "from typing import Annotated, Sequence, TypedDict\n",
    "\n",
    "from langchain_openai import ChatOpenAI\n",
    "\n",
    "\n",
    "# This defines the object that is passed between each node\n",
    "# in the graph. We will create different nodes for each agent and tool\n",
    "class AgentState(TypedDict):\n",
    "    messages: Annotated[Sequence[BaseMessage], operator.add]\n",
    "    sender: str"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "911a283e-ea04-40c1-b792-f9e5f7d81203",
   "metadata": {},
   "source": [
    "## 3.2 定义 Agent 节点\n",
    "\n",
    "在定义了状态之后，我们接下来就需要定义用于构建 Graph 的节点了。首先是 Agent 节点"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "71b790ca-9cef-4b22-b469-4b1d5d8424d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import functools\n",
    "import re\n",
    "\n",
    "from langchain_core.messages import AIMessage\n",
    "\n",
    "\n",
    "# Helper function to create a node for a given agent\n",
    "def agent_node(state, agent, name):\n",
    "    messages = state[\"messages\"]\n",
    "    last_message = messages[-1]\n",
    "\n",
    "    if isinstance(last_message, AIMessage):\n",
    "        messages.append(HumanMessage(content=\"Please continue your thinking\"))\n",
    "        state[\"messages\"] = messages\n",
    "\n",
    "    result = agent.invoke(state)\n",
    "    # We convert the agent output into a format that is suitable to append to the global state\n",
    "    if isinstance(result, ToolMessage):\n",
    "        pass\n",
    "    else:\n",
    "        result = AIMessage(**result.dict(exclude={\"type\", \"name\"}), name=name)\n",
    "    return {\n",
    "        \"messages\": [result],\n",
    "        # Since we have a strict workflow, we can\n",
    "        # track the sender so we know who to pass to next.\n",
    "        \"sender\": name,\n",
    "    }\n",
    "\n",
    "def extract_markdown_code_blocks(text):\n",
    "    code_block_pattern = re.compile(r'```python(.*?)```', re.DOTALL)\n",
    "\n",
    "    code_blocks = code_block_pattern.findall(text)\n",
    "    \n",
    "    return code_blocks\n",
    "\n",
    "\n",
    "# Helper function to create a code node for a given agent\n",
    "def code_agent_node(state, agent, name):\n",
    "    messages = state[\"messages\"]\n",
    "    last_message = messages[-1]\n",
    "\n",
    "    if isinstance(last_message, AIMessage):\n",
    "        messages.append(HumanMessage(content=\"Please continue your thinking\"))\n",
    "        state[\"messages\"] = messages\n",
    "\n",
    "    result = agent.invoke(state)\n",
    "    # We convert the agent output into a format that is suitable to append to the global state\n",
    "    \n",
    "    from langchain_core.messages import ToolCall\n",
    "\n",
    "    code_blocks = extract_markdown_code_blocks(result.content)\n",
    "    if code_blocks:\n",
    "        code_block = code_blocks[0]\n",
    "        result = AIMessage(content=\"\", tool_calls=[ToolCall(name=\"python_repl\", args={\"code\": code_block}, id=\"python_repl\")])\n",
    "    \n",
    "    if isinstance(result, ToolMessage):\n",
    "        pass\n",
    "    else:\n",
    "        result = AIMessage(**result.dict(exclude={\"type\", \"name\"}), name=name)\n",
    "    return {\n",
    "        \"messages\": [result],\n",
    "        # Since we have a strict workflow, we can\n",
    "        # track the sender so we know who to pass to next.\n",
    "        \"sender\": name,\n",
    "    }\n",
    "\n",
    "llm = ChatOpenAI(model=\"ERNIE-Functions-8K\")\n",
    "llm_code_gen = ChatOpenAI(model=\"ERNIE-4.0-8K\")\n",
    "\n",
    "# Research agent and node\n",
    "research_agent = create_agent(\n",
    "    llm,\n",
    "    [duckduckgo_search],\n",
    "    system_message=\"You should provide accurate data for the chart_generator to use.\",\n",
    ")\n",
    "research_node = functools.partial(agent_node, agent=research_agent, name=\"Researcher\")\n",
    "\n",
    "# chart_generator\n",
    "chart_agent = create_agent(\n",
    "    llm_code_gen,\n",
    "    [python_repl],\n",
    "    system_message=\"Any charts you display will be visible by the user.\",\n",
    ")\n",
    "chart_node = functools.partial(code_agent_node, agent=chart_agent, name=\"chart_generator\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71c7f1b2-24a3-4340-bcb2-feb22e344fb6",
   "metadata": {},
   "source": [
    "## 3.3 定义工具节点\n",
    "\n",
    "除了决策用的 Agent 节点之外，我们还需要定义一个工具节点，来运行从 Agent 节点传递的调用信息"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d9a79c76-5c7c-42f6-91cf-635bc8305804",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langgraph.prebuilt import ToolNode\n",
    "\n",
    "tools = [duckduckgo_search, python_repl]\n",
    "tool_node = ToolNode(tools)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcb30498-dbc4-4b20-980f-da08ebc9da56",
   "metadata": {},
   "source": [
    "## 3.4 定义边\n",
    "\n",
    "不同节点之间需要用边来链接，LangGraph 支持根据节点输出的状态，依据一定条件来构造边的行为。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "4f4b4d37-e8a3-4abb-8d42-eaea26016f35",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Either agent can decide to end\n",
    "from typing import Literal\n",
    "\n",
    "\n",
    "def router(state) -> Literal[\"call_tool\", \"__end__\", \"continue\"]:\n",
    "    # This is the router\n",
    "    messages = state[\"messages\"]\n",
    "    last_message = messages[-1]\n",
    "    if last_message.tool_calls:\n",
    "        # The previous agent is invoking a tool\n",
    "        return \"call_tool\"\n",
    "    if \"FINAL ANSWER\" in last_message.content:\n",
    "        # Any agent decided the work is done\n",
    "        return \"__end__\"\n",
    "    \n",
    "    return \"continue\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9359c34-e191-43a2-a3d4-f2dea636dfd2",
   "metadata": {},
   "source": [
    "## 3.5 定义图\n",
    "\n",
    "在构造完上述组件之后，我们接下来可以将它们组合在一起构造为 Graph。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "4dce3901-6ad5-4df5-8528-6e865cf96cb0",
   "metadata": {},
   "outputs": [],
   "source": [
    "workflow = StateGraph(AgentState)\n",
    "\n",
    "workflow.add_node(\"Researcher\", research_node)\n",
    "workflow.add_node(\"chart_generator\", chart_node)\n",
    "workflow.add_node(\"call_tool\", tool_node)\n",
    "\n",
    "workflow.add_conditional_edges(\n",
    "    \"Researcher\",\n",
    "    router,\n",
    "    {\"continue\": \"chart_generator\", \"call_tool\": \"call_tool\", \"__end__\": END},\n",
    ")\n",
    "workflow.add_conditional_edges(\n",
    "    \"chart_generator\",\n",
    "    router,\n",
    "    {\"continue\": \"Researcher\", \"call_tool\": \"call_tool\", \"__end__\": END},\n",
    ")\n",
    "\n",
    "workflow.add_conditional_edges(\n",
    "    \"call_tool\",\n",
    "    # Each agent node updates the 'sender' field\n",
    "    # the tool calling node does not, meaning\n",
    "    # this edge will route back to the original agent\n",
    "    # who invoked the tool\n",
    "    lambda x: x[\"sender\"],\n",
    "    {\n",
    "        \"Researcher\": \"Researcher\",\n",
    "        \"chart_generator\": \"chart_generator\",\n",
    "    },\n",
    ")\n",
    "workflow.add_edge(START, \"Researcher\")\n",
    "graph = workflow.compile()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "97f8e0eb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from IPython.display import Image, display\n",
    "\n",
    "try:\n",
    "    display(Image(graph.get_graph(xray=True).draw_mermaid_png()))\n",
    "except Exception:\n",
    "    # This requires some extra dependencies and is optional\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c9447e7-9ab6-43eb-8ae6-9b52f8ba8425",
   "metadata": {},
   "source": [
    "# 4. 运行\n",
    "\n",
    "接下来我们就可以运行了"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "176a99b0-b457-45cf-8901-90facaa852da",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Researcher': {'messages': [AIMessage(content='', additional_kwargs={'function_call': {'arguments': '{\"query\": \"US GDP between 2010 and 2020\"}', 'name': 'duckduckgo_search'}, 'tool_calls': [{'id': 'duckduckgo_search', 'function': {'arguments': '{\"query\": \"US GDP between 2010 and 2020\"}', 'name': 'duckduckgo_search'}, 'type': 'function'}], 'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 30, 'prompt_tokens': 236, 'total_tokens': 266}, 'model_name': 'ERNIE-Functions-8K', 'system_fingerprint': 'fp_?', 'finish_reason': 'tool_calls', 'logprobs': None}, name='Researcher', id='run-54cfe4a0-3104-4656-899e-3d750d026c10-0', tool_calls=[{'name': 'duckduckgo_search', 'args': {'query': 'US GDP between 2010 and 2020'}, 'id': 'duckduckgo_search', 'type': 'tool_call'}], usage_metadata={'input_tokens': 236, 'output_tokens': 30, 'total_tokens': 266})], 'sender': 'Researcher'}}\n",
      "----\n",
      "{'call_tool': {'messages': [ToolMessage(content='{\\n  \"GDP_USA_2010_2020\": {\\n    \"2010\": 14964.4,\\n    \"2011\": 15518.9,\\n    \"2012\": 16197.0,\\n    \"2013\": 16784.9,\\n    \"2014\": 17527.3,\\n    \"2015\": 18224.8,\\n    \"2016\": 18745.1,\\n    \"2017\": 19519.4,\\n    \"2018\": 20611.9,\\n    \"2019\": 21433.2,\\n    \"2020\": 20936.6\\n  }\\n}', name='duckduckgo_search', tool_call_id='duckduckgo_search')]}}\n",
      "----\n",
      "{'Researcher': {'messages': [AIMessage(content='I have found the GDP of the US between 2010 and 2020. Here are the values:\\n\\n- 2010: $14,964.4 billion\\n- 2011: $15,518.9 billion\\n- 2012: $16,197.0 billion\\n- 2013: $16,784.9 billion\\n- 2014: $17,527.3 billion\\n- 2015: $18,224.8 billion\\n- 2016: $18,745.1 billion\\n- 2017: $19,519.4 billion\\n- 2018: $20,611.9 billion\\n- 2019: $21,433.2 billion\\n- 2020: $20,936.6 billion\\n\\nNow, I will draw a line graph of these values.', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 239, 'prompt_tokens': 483, 'total_tokens': 722}, 'model_name': 'ERNIE-Functions-8K', 'system_fingerprint': 'fp_?', 'finish_reason': 'normal', 'logprobs': None}, name='Researcher', id='run-247e853f-9adf-47f5-9613-b8b039f19a56-0', usage_metadata={'input_tokens': 483, 'output_tokens': 239, 'total_tokens': 722})], 'sender': 'Researcher'}}\n",
      "----\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Python REPL can execute arbitrary code. Use with caution.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'chart_generator': {'messages': [AIMessage(content='', name='chart_generator', tool_calls=[{'name': 'python_repl', 'args': {'code': \"\\nimport matplotlib.pyplot as plt\\n\\n# GDP data for the US from 2010 to 2020 (in billions of USD)\\nyears = list(range(2010, 2021))\\ngdp_values = [14964.4, 15518.9, 16197.0, 16784.9, 17527.3, 18224.8, 18745.1, 19519.4, 20611.9, 21433.2, 20936.6]\\n\\n# Create a line graph\\nplt.plot(years, gdp_values, marker='o')\\n\\n# Add titles and labels\\nplt.title('US GDP from 2010 to 2020')\\nplt.xlabel('Year')\\nplt.ylabel('GDP (in billions of USD)')\\nplt.grid(True)\\nplt.show()\\n\"}, 'id': 'python_repl', 'type': 'tool_call'}])], 'sender': 'chart_generator'}}\n",
      "----\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'call_tool': {'messages': [ToolMessage(content=\"Successfully executed:\\n```python\\n\\nimport matplotlib.pyplot as plt\\n\\n# GDP data for the US from 2010 to 2020 (in billions of USD)\\nyears = list(range(2010, 2021))\\ngdp_values = [14964.4, 15518.9, 16197.0, 16784.9, 17527.3, 18224.8, 18745.1, 19519.4, 20611.9, 21433.2, 20936.6]\\n\\n# Create a line graph\\nplt.plot(years, gdp_values, marker='o')\\n\\n# Add titles and labels\\nplt.title('US GDP from 2010 to 2020')\\nplt.xlabel('Year')\\nplt.ylabel('GDP (in billions of USD)')\\nplt.grid(True)\\nplt.show()\\n\\n```\\nStdout: \\n\\nIf you have completed all tasks, respond with FINAL ANSWER.\", name='python_repl', tool_call_id='python_repl')]}}\n",
      "----\n",
      "{'chart_generator': {'messages': [AIMessage(content='I have created a line graph showing the US GDP from 2010 to 2020. The graph displays the trend of the GDP over this period, clearly indicating the changes from year to year. If you would like to see the graph, please let me know and I can provide it to you.\\n\\nFINAL ANSWER.', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 71, 'prompt_tokens': 855, 'total_tokens': 926}, 'model_name': 'ERNIE-4.0-8K', 'system_fingerprint': 'fp_?', 'finish_reason': 'normal', 'logprobs': None}, name='chart_generator', id='run-f493f77c-8228-4359-a12f-c39daa6fbe42-0', usage_metadata={'input_tokens': 855, 'output_tokens': 71, 'total_tokens': 926})], 'sender': 'chart_generator'}}\n",
      "----\n"
     ]
    }
   ],
   "source": [
    "events = graph.stream(\n",
    "    {\n",
    "        \"messages\": [\n",
    "            HumanMessage(\n",
    "                content=\"Fetch the US's GDP between 2010 and 2020,\"\n",
    "                \" then draw a line graph of it.\"\n",
    "                \" Once you code it up, finish.\"\n",
    "            )\n",
    "        ],\n",
    "    },\n",
    "    # Maximum number of steps to take in the graph\n",
    "    {\"recursion_limit\": 150},\n",
    ")\n",
    "for s in events:\n",
    "    print(s)\n",
    "    print(\"----\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
